#targetengine "session"
#target indesign

// 给图片对象应用用户指定的对象样式（处理嵌套图形的最外层框架，避免影响文本框架）
main();

function main() {
    // 检查是否有打开的文档
    if (app.documents.length === 0) {
        alert("请先打开一个InDesign文档");
        return;
    }
    
    var doc = app.activeDocument;
    
    // ===== 收集对象样式的完整路径名和样式对象映射 =====
    function getAllObjectStylesWithPaths(styleGroup, pathPrefix, resultList, styleMap) {
        var styles = styleGroup.objectStyles;
        for (var i = 0; i < styles.length; i++) {
            var style = styles[i];
            if (style.name !== "[Normal Object Style]") {
                var fullName = pathPrefix + style.name;
                resultList.push(fullName);
                styleMap[fullName] = style;
            }
        }

        var groups = styleGroup.objectStyleGroups;
        for (var j = 0; j < groups.length; j++) {
            var group = groups[j];
            getAllObjectStylesWithPaths(group, pathPrefix + group.name + "/", resultList, styleMap);
        }
    }

    var objectStyleNames = [];
    var objectStyleMap = {};
    getAllObjectStylesWithPaths(doc, "", objectStyleNames, objectStyleMap);

    if (objectStyleNames.length === 0) {
        alert("文档中没有可用的对象样式。请先创建对象样式。");
        return;
    }
    
    // ===== 创建对话框 =====
    var dialog = app.dialogs.add({ name: "应用对象样式到图片" });
    with (dialog.dialogColumns.add()) {
        var styleDropdown = dropdowns.add({
            stringList: objectStyleNames,
            selectedIndex: 0,
            minWidth: 200,
            staticLabel: "选择对象样式"
        });
    }

    if (dialog.show() === true) {
        var selectedStyleName = styleDropdown.stringList[styleDropdown.selectedIndex];
        var selectedStyle = objectStyleMap[selectedStyleName];

        if (!selectedStyle.isValid) {
            alert("所选样式无效。");
            dialog.destroy();
            return;
        }
        
        dialog.destroy();
    
        // 询问用户是处理整个文档还是仅当前页面
        var processAll = Window.confirm("是否处理整个文档中的所有图片？\n点击'确定'处理整个文档，点击'取消'仅处理当前页面。");
        
        // 使用doScript方法包装整个操作，以便可以一步撤销
        if (processAll) {
            app.doScript(function() { processDocumentImages(selectedStyle); }, ScriptLanguage.JAVASCRIPT, undefined, UndoModes.entireScript, "给文档图片应用对象样式");
        } else {
            app.doScript(function() { processPageImages(selectedStyle); }, ScriptLanguage.JAVASCRIPT, undefined, UndoModes.entireScript, "给页面图片应用对象样式");
        }
    } else {
        dialog.destroy();
    }
}

// 检查对象是否为合适的图形容器（支持对象样式且不是文本框架、编组或字符）
function isValidGraphicsObject(obj) {
    try {
        // 排除文本框架
        if (obj instanceof TextFrame) {
            return false;
        }
        
        // 排除编组
        if (obj instanceof Group) {
            return false;
        }
        
        // 排除字符对象（Character）
        if (obj instanceof Character) {
            return false;
        }
        
        // 检查对象是否支持对象样式（使用in操作符包括继承属性）
        return 'appliedObjectStyle' in obj;
    } catch (e) {
        return false;
    }
}

// 检查图形是否在文本框架内（通过遍历父对象链查找TextFrame）
function isInTextFrame(graphic) {
    try {
        var current = graphic;
        var maxDepth = 20; // 安全限制，防止无限循环
        var depth = 0;
        
        while (current && depth < maxDepth) {
            if (current instanceof TextFrame) {
                return true;
            }
            if (current.parent) {
                current = current.parent;
                depth++;
            } else {
                break;
            }
        }
        return false;
    } catch (e) {
        return false;
    }
}

// 查找图形的最外层框架（针对嵌套图形）
function findOutermostGraphicsFrame(graphic) {
    var parent = graphic.parent;
    var safetyCounter = 0;
    
    while (parent && safetyCounter < 10) {
        if (isValidGraphicsObject(parent)) {
            return parent;
        }
        parent = parent.parent;
        safetyCounter++;
    }
    
    // 如果没有找到有效的父级框架，则返回图形的拥有者（例如Rectangle、Polygon等）
    var owningFrame = graphic.parent;
    if (owningFrame && isValidGraphicsObject(owningFrame)) {
        return owningFrame;
    }
    
    return null;
}

// 处理整个文档中的图片
function processDocumentImages(objectStyle) {
    var doc = app.activeDocument;
    var count = 0;
    var textFrameGraphicCount = 0;
    var skippedCharacters = 0;
    
    try {
        // 首先处理文本框架内的图形
        var textFrames = doc.textFrames;
        for (var i = 0; i < textFrames.length; i++) {
            var textFrame = textFrames[i];
            if (!textFrame.isValid) continue;
            
            var items = textFrame.allPageItems; // 包含锚定对象
            for (var j = 0; j < items.length; j++) {
                var item = items[j];
                if (!item || !item.isValid) continue;
                
                // 显式跳过字符对象
                if (item instanceof Character) {
                    skippedCharacters++;
                    continue;
                }
                
                // 仅处理父级为Character的Rectangle对象（常见的锚定图形）
                if (item.constructor && item.constructor.name === "Rectangle" &&
                    item.parent && item.parent.constructor && item.parent.constructor.name === "Character") {
                    
                    // 确保是一个有效的图形对象
                    if (isValidGraphicsObject(item)) {
                        try {
                            item.appliedObjectStyle = objectStyle;
                            count++;
                            textFrameGraphicCount++;
                        } catch (e) {
                            // 忽略错误，继续处理其他图形
                        }
                    }
                }
            }
        }
        
        // 然后处理非文本框架内的图形
        var allGraphics = doc.allGraphics;
        for (var i = 0; i < allGraphics.length; i++) {
            var graphic = allGraphics[i];
            
            // 安全检查：跳过字符对象
            if (graphic instanceof Character) {
                skippedCharacters++;
                continue;
            }
            
            // 检查是否为图片类型且不在文本框架内
            if ((graphic instanceof Image ||
                 graphic instanceof PDF ||
                 graphic instanceof ImportedPage ||
                 graphic instanceof EPS) &&
                !isInTextFrame(graphic)) {
                
                var targetObject = findOutermostGraphicsFrame(graphic);
                
                // 确保找到的对象是有效图形对象
                if (targetObject && isValidGraphicsObject(targetObject)) {
                    try {
                        targetObject.appliedObjectStyle = objectStyle;
                        count++;
                    } catch (e) {
                        // 忽略错误，继续处理其他图形
                    }
                }
            }
        }
        
        alert("已完成处理 " + count + " 个图形对象（包括 " + textFrameGraphicCount + " 个文本框架内的图形），跳过了 " + skippedCharacters + " 个字符对象，已应用对象样式 '" + objectStyle.name + "'。");
        
    } catch (e) {
        alert("执行过程中出现错误:\n" + e.message);
    }
}

// 处理当前页面中的图片
function processPageImages(objectStyle) {
    var doc = app.activeDocument;
    var page = doc.layoutWindows[0].activePage; // 获取当前页面
    
    try {
        var count = 0;
        var textFrameGraphicCount = 0;
        var skippedCharacters = 0;
        
        // 首先处理当前页面文本框架内的图形
        var pageTextFrames = page.textFrames;
        for (var t = 0; t < pageTextFrames.length; t++) {
            var tf = pageTextFrames[t];
            if (!tf.isValid) continue;
            
            var items = tf.allPageItems; // 包含锚定对象
            for (var j = 0; j < items.length; j++) {
                var it = items[j];
                if (!it || !it.isValid) continue;
                
                // 显式跳过字符对象
                if (it instanceof Character) {
                    skippedCharacters++;
                    continue;
                }
                
                // 仅处理父级为Character的Rectangle对象
                if (it.constructor && it.constructor.name === "Rectangle" &&
                    it.parent && it.parent.constructor && it.parent.constructor.name === "Character") {
                    
                    // 确保是有效的图形对象
                    if (isValidGraphicsObject(it)) {
                        try {
                            it.appliedObjectStyle = objectStyle;
                            count++;
                            textFrameGraphicCount++;
                        } catch (e) {
                            // 忽略错误，继续处理其他图形
                        }
                    }
                }
            }
        }
        
        // 然后处理非文本框架内的图形
        var pageGraphics = page.allGraphics;
        for (var i = 0; i < pageGraphics.length; i++) {
            var graphic = pageGraphics[i];
            
            // 安全检查：跳过字符对象
            if (graphic instanceof Character) {
                skippedCharacters++;
                continue;
            }
            
            // 检查是否为图片类型且不在文本框架内
            if ((graphic instanceof Image ||
                 graphic instanceof PDF ||
                 graphic instanceof ImportedPage ||
                 graphic instanceof EPS) &&
                !isInTextFrame(graphic)) {
                
                var targetObject = findOutermostGraphicsFrame(graphic);
                
                // 确保找到的对象是有效图形对象
                if (targetObject && isValidGraphicsObject(targetObject)) {
                    try {
                        targetObject.appliedObjectStyle = objectStyle;
                        count++;
                    } catch (e) {
                        // 忽略错误，继续处理其他图形
                    }
                }
            }
        }
        
        //alert("已完成处理当前页面上的 " + count + " 个图形对象（包括 " + textFrameGraphicCount + " 个文本框架内的图形），跳过了 " + skippedCharacters + " 个字符对象，已应用对象样式 '" + objectStyle.name + "'。");
        
    } catch (e) {
        alert("执行过程中出现错误:\n" + e.message);
    }
}
